package com.zhidian.edm.util;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * 列表工具类
 */
public class ListUtil {

    /**
     * 将对象列表转换为指定属性的列表
     *
     * @param sourceList 原始列表
     * @param mapper     属性获取函数，例如 User::getName
     * @param <T>        原始对象类型
     * @param <R>        返回属性类型
     * @return 属性值列表
     */
    public static <T, R> List<R> toValueList(List<T> sourceList, Function<T, R> mapper) {
        if (sourceList == null || sourceList.isEmpty()) {
            // JDK9+ 不可变空集合
            return List.of();
        }
        return sourceList.stream()
                .map(mapper)
                .collect(Collectors.toList());
    }

    /**
     * 将对象列表转换为 Map
     *
     * @param sourceList   原始列表
     * @param keyMapper    key 提取函数
     * @param valueMapper  value 提取函数
     * @param <T>          原始对象类型
     * @param <K>          key 类型
     * @param <V>          value 类型
     * @return Map<K,V>
     */
    public static <T, K, V> Map<K, V> toValueMap(List<T> sourceList,
                                                 Function<T, K> keyMapper,
                                                 Function<T, V> valueMapper) {
        if (sourceList == null || sourceList.isEmpty()) {
            // JDK9+ 不可变空 Map
            return Map.of();
        }
        return sourceList.stream()
                .collect(Collectors.toMap(
                        keyMapper,
                        valueMapper,
                        // 处理 key 冲突时，保留最新的
                        (oldVal, newVal) -> newVal
                ));
    }

    /**
     * 分组：把 List 转换为 Map<K, List<V>>
     */
    public static <T, K, V> Map<K, List<V>> toGroupingMap(List<T> sourceList,
                                                          Function<T, K> keyMapper,
                                                          Function<T, V> valueMapper) {
        if (sourceList == null || sourceList.isEmpty()) {
            return Map.of();
        }
        return sourceList.stream()
                .collect(Collectors.groupingBy(
                        keyMapper,
                        Collectors.mapping(valueMapper, Collectors.toList())
                ));
    }

    /**
     * 下标索引映射：把 List 转换为 Map<index, element>
     */
    public static <T> Map<Integer, T> toIndexMap(List<T> sourceList) {
        if (sourceList == null || sourceList.isEmpty()) {
            return Map.of();
        }
        return IntStream.range(0, sourceList.size())
                .boxed()
                .collect(Collectors.toMap(i -> i, sourceList::get));
    }
}